פרק 7 ביצוע-חוזר 7.1 ביצוע-חוזר מספר פעמים ידוע מראש 1 בעיה הביצוע-החוזר.

Transcription

1 פרק 7 ביצוע-חוזר עד כה הכרנו בעיות אשר לשם פתרונן ביצענו מספר תת-משימות שונות, באופן סדרתי. כלומר כל תת-משימה בסדרה בוצעה פעם אחת (ואם זו משימה שביצועה תלוי בתנאי, ייתכן שלא בוצעה אפילו פעם אחת). אולם יש בעיות אשר לצורך פתרונן יש לבצע תת-משימה אחת, או כמה תת- משימות, יותר מפעם אחת, ואולי אף מספר רב של פעמים. בפרק זה נכיר אלגוריתמים אשר מורים על חזרה שוב ושוב על ביצוע של תת-משימה (או תת-משימות). אלגוריתמים אלה כוללים הוראה לביצוע-חוזר של קבוצת הוראות. בסעיף 7.1 נכיר אלגוריתמים שמבנה הביצוע-החוזר בהם הוא פשוט. באלגוריתמים אלה מספר הפעמים של הביצוע-החוזר נקבע לפני תחילת ביצועו. בסעיף 7.4 נכיר אלגוריתמים שמבנה הביצוע-החוזר בהם מורכב יותר. באלגוריתמים אלה מספר הפעמים של הביצוע-החוזר לא נקבע מראש, אלא תלוי בתנאי אשר נבדק שוב ושוב במהלך הביצוע-החוזר. 7.1 ביצוע-חוזר מספר פעמים ידוע מראש 1 בעיה מטרת הבעיה ופתרונה: הצגת אלגוריתם הכולל הוראה לביצוע-חוזר מספר פעמים ידוע מראש. עלינו להמיר רשימת מחירים מייצוג בדולרים לייצוג בשקלים. פתחו וישמו אלגוריתם אשר הקלט שלו הוא שער ההמרה מדולרים לשקלים ואחריו רשימה של עשרה מחירים הנתונים בדולרים. הפלט שלו הוא הערך בשקלים של כל אחד מעשרת המחירים. הפלט עבור כל מחיר צריך להינתן מיד אחרי קליטתו ולפני קליטת המחיר הבא. פירוק הבעיה לתת-משימות.1.2? קליטת שער ההמרה מדולרים לשקלים קליטת כל אחד מעשרת המחירים בדולרים, חישוב ערכו בשקלים והצגת הערך המחושב ניתן לפרט את התת-משימה השנייה. כיצד? התת-משימה השנייה מורכבת בעצם מביצוע-חוזר, עשר פעמים, של התת-משימות הבאות: 2.1 קליטת מחיר בדולרים 2.2 חישוב ערכו של המחיר בשקלים 2.3 הצגה של הערך המחושב דרך אחת להורות על ביצוע החוזר עשר פעמים על התת-משימות שניסחנו, היא כמובן לכתוב אותן עשר פעמים, כך: 2.1. קליטת מחיר בדולרים חישוב ערכו של המחיר בשקלים הצגה של הערך המחושב קליטת מחיר בדולרים חישוב ערכו של המחיר בשקלים 2.6. הצגה של הערך המחושב

2 קליטת מחיר בדולרים חישוב ערכו של המחיר בשקלים הצגה של הערך המחושב זהו ניסוח מסורבל כמובן. עבור רשימה של עשרה מחירים נכתבות שלושים הוראות. עבור רשימה של מאה מחירים ייכתבו 300 הוראות. ובעצם, עבור רשימות מחירים באורכים שונים ייכתבו אלגוריתמים שבהם מספר הוראות שונה. כלומר, לא רק שמדובר באלגוריתמים ארוכים מאוד, יש צורך לבצע שינוי משמעותי (מספר המחירים), אלא שעבור שינוי קטן בהגדרת הבעיה באלגוריתם. האם ניתן להימנע מן הסרבול המתואר? האם ניתן לכתוב אלגוריתם שבו יהיה אותו מספר הוראות עבור רשימות מחירים באורכים שונים? אכן ניתן באמצעות הוראה לביצוע-חוזר לקבוצת הוראות. בפתרון הבעיה הנוכחית שבה יש להמיר עשרה מחירים ניתן להשתמש בהוראה הבאה לביצוע-חוזר: :íéîòô 10 íéøìåãá øéçî èåì íéì ùá øéçîä ìù åëøò úà áùç áùåçîä êøòä úà âöä òöá עבור רשימה של 100 מחירים ניתן לכתוב אלגוריתם הכולל הוראה לביצוע-חוזר במבנה זהה, אלא שמספר הפעמים המצוין בו בכותרת ההוראה הוא 100 במקום 10. שימו להזחה בהוראה לביצוע-חוזר. בהוראה זו (כמו בהוראה לביצוע-בתנאי) אנו מזיחים פנימה את קבוצת ההוראה לביצוע-חוזר. בחירת משתנים נשתמש במשתנים הבאים מטיפוס ממשי: rate ישמור את שער ההמרה מדולרים לשקלים. dollarprice ישמור מחיר בדולרים ישמור את ערכו בשקלים של המחיר השמור ב- dollarprice shekelprice íùäå האלגוריתם rate-á äøîä øòù èåì :íéîòô 10 dollarprice-á øéçî èåì dollarprice-á øåîùä øéçîä ìù íéì ùá åëøò úà áùç shekelprice-á shekelprice ìù åëøò úà âöä òöá

3 יישום האלגוריתם הוראה לביצוע-חוזר במבנה של...íéîòô øôñî òöá מיושמת ב-# C במשפט.for משפט למשל אם ברצוננו לבצע קבוצת for (i = 1; i <= 10; i++) ההוראות לביצוע } for משתמש במשתנה בקרה, אשר שולט בביצוע הלולאה. הוראות 10 פעמים, נכתוב משפט for בצורה הבאה: משתנה הבקרה במשפט זה הוא i. ערכו מאותחל ב- 1 (כפי שמורה משפט ההשמה = 1 i, המהווה את הרכיב הראשון בסוגריים). אחרי שסדרת ההוראות לביצוע מתבצעת פעם אחת ערכו של משתנה הבקרה גדל ב- 1 (על כך מורה הרכיב השלישי בסוגריים: ++i), והביצוע-החוזר יימשך כל עוד ערכו של i קטן או שווה ל- 10 (כפי שמורה התנאי => 10 i, הרכיב השני בסוגריים). אם כך בתחילת הביצוע של משפט ה- for, i יאותחל ב- 1. אחרי שקבוצת ההוראות לביצוע תבוצע פעם אחת, ערכו יגדל ל- 2. אחרי שקבוצת ההוראות תבוצע פעם שנייה, ערכו יגדל ל- 3. אחרי שקבוצת ההוראות תבוצע פעם עשירית, ערכו כבר יהיה 11, ואז יסתיים הביצוע-החוזר, משום שערכו של התנאי => 10 i יהיה.false באופן כללי, בביצוע משפט for מושם ערך התחלתי במשתנה הבקרה לפי הרכיב הראשון במשפט. לאחר מכן מתבצעת בדיקת התנאי, המתואר ברכיב השני. אם ערכו של התנאי הוא true מתבצעות ההוראות לביצוע. בתום ביצוע קבוצת ההוראות גדל ערכו של משתנה הבקרה לפי הרכיב השלישי. כעת מתבצעת שוב בדיקת התנאי. אם ערכו של התנאי הוא true מתבצעת שוב קבוצת ההוראות וכך הלאה, עד אשר ערכו של התנאי הוא false ואז מסתיים הביצוע. באופן דומה, ניתן היה לבחור גם במשפט ה- for הבא ליישום ההוראה לביצוע-חוזר באלגוריתם: for (i = 0; i < 10; i++) הוראות לביצוע } גם במקרה זה ההוראות לביצוע מתבצעות 10 פעמים: פעם אחת כאשר ערכו של i שווה ל- 0, פעם שנייה כאשר ערכו שווה ל- 1, פעם שלישית כאשר ערכו שווה ל- 2, ובפעם העשירית ואחרונה כאשר ערכו של i שווה ל- 9. כאשר ערכו של i גדל שוב, ומגיע ל- 10, התנאי להמשך הביצוע כבר לא מתקיים, והביצוע-החוזר מסתיים. שימו : ההוראה ++i היא למעשה הוראת השמה מקוצרת. היא שקולה להוראת ההשמה:.for ניתן להשתמש בהוראה זו בכל מקום בתוכנית, לאו דווקא במשפט i. = i + 1 התוכנית המלאה /* הקלט: שער ההמרה מדולרים לשקלים ורשימה של 10 מחירים בדולרים הפלט: הערכים השקליים של 10 המחירים הנתונים בדולרים */ using System; public class Convertor public static void Main () קבוע : מספר המחירים הנקראים מהקלט // HOW_MANY=10; const int

4 double rate; שער ההמרה// dollarprice; double מחיר בדולרים// shekelprice; double מחיר בשקלים// int i; משתנה בקרה// קלט // 1. Console.Write("Enter the rate: "); 2. rate = double.parse(console.readline()); // ההוראה לביצוע-חוזר 3. for (i = 1; i <= HOW_MANY; i++) 3.1. Console.Write("Enter price in Dollars: "); 3.2. dollarprice = double.parse(console.readline()); 3.3. shekelprice = dollarprice * rate; 3.4. Console.WriteLine("Price in Shekels is 0}", shekelprice); }// for }// Main }// Convertor מעקב בטבלת מעקב הכוללת משפט for נכלול עמודה עבור משתנה הבקרה של המשפט. בתוכנית לפתרון בעיה 1, ערכו של משתנה הבקרה i גדל ב- 1 אחרי כל ביצוע של קבוצת ההוראות הכלולה במשפט ה- for. ערכו בביצוע-החוזר הראשון הוא 1 וערכו בביצוע-החוזר האחרון הוא 10. בנוסף לכך, טבלת המעקב תכלול עמודה עבור התנאי הבוליאני שבכותרת המשפט. נעקוב אחר ביצוע התוכנית עבור הקלט הבא: שער ההמרה הוא 3, ועשרת המחירים להמרה הם: כדי להימנע מהצגת טבלה ארוכה מדי, תכלול הטבלה הבאה מעקב רק אחרי עיבוד שני המחירים הראשונים והמחיר האחרון שבקלט. המשפט לביצוע i i<=10 rate dollar shekel פלט Console.Write("Enter the rate:");???? Enter the rate rate = double.parse(console.? 3?? ReadLine()); for (i = 1; i <= 10; i++) 1 true 3?? Console.Write("Enter price in 1 3?? Enter Dollars: "); price dollarprice = double.parse( ? Console.ReadLine()); shekelprice = dollarprice * rate; Console.WriteLine("Price in Shekels is 0}",shekelPrice); for (i = 1; i <= 10; i++) Console.Write("Enter price in Dollars: "); dollarprice = double.parse( Console.ReadLine()); shekelprice = dollarprice * true Price in Shekels is 30.3 Enter price

5 rate; Console.WriteLine("Price in Shekels is 0}",shekelPrice); for (i = 1; i <= 10; i++) Console.Write("Enter price in Dollars: "); dollarprice = double.parse( Console.ReadLine()); shekelprice = dollarprice * rate; Console.WriteLine("Price in Shekels is 0}",shekelPrice); for (i = 1; i <= 10; i++) true false Price in Shekels is 15 Enter price Price in Shekels is 300 שימו לב לשינויים שחלים בערכו של משתנה הבקרה i ולבדיקת התנאי של משתנה הבקרה. נציג את המושגים החדשים שהכרנו בפתרון לבעיה 1. הוראה לביצוע-חוזר סוף במבנה פתרון בעיה 1 øôñî òöá באלגוריתם לפתרון הבעיה כללנו...íéîòô כדי לציין ביצוע-חוזר של תת-משימה. הוראה זו מורה על ביצוע-חוזר של קבוצת הוראות מספר פעמים. הוראה לביצוע-חוזר היא הוראת בקרה. הוראה לביצוע-חוזר נקראת גוף הלולאה. גם לולאה,(loop) וקבוצת ההוראות לביצוע הכלולות בה נקראת בדומה לכתיבה של הוראה לביצוע-בתנאי גם כתיבה של הוראה לביצוע-חוזר נעשית תוך הקפדה על הזחה מתאימה: קבוצת ההוראות שיש לחזור על ביצוען מוזחת פנימה. בשפת #C מיושמת הוראה לביצוע-חוזר במבנה זה במשפט.for זהו המבנה הכללי של משפט for בשפת #C: (שינוי משתנה הבקרה ;התנאי להמשך הביצוע ;אתחול משתנה הבקרה) for הוראות לביצוע } אתחול משתנה הבקרה: הוראת השמה הקובעת ערך התחלתי למשתנה הבקרה. התנאי להמשך הביצוע: ביטוי בוליאני שמהווה את התנאי השולט בביצוע-החוזר. התנאי נבדק אחרי אתחול משתנה הבקרה. כמו כן הוא נבדק שוב בכל פעם שמסתיים ביצוע של קבוצת ההוראות-לביצוע. כל עוד התנאי מתקיים הביצוע-החוזר ממשיך. כאשר ערכו של התנאי הוא false הביצוע-החוזר מסתיים. שינוי משתנה הבקרה: השינוי שחל במשתנה הבקרה בכל פעם שמסתיים שלב ביצוע נוסף. גוף הלולאה תחום בסוגריים מסולסלים. במקרה שגוף הלולאה מכיל משפט בודד אפשר להשמיט את הסוגריים

6 for (i = 0; i < 10; i++) Console.Write("*"); for למשל כך: בטבלת מעקב אחר תוכנית הכוללת משפט ועמודה עבור התנאי להמשך הביצוע. אנו כוללים עמודה עבור משתנה הבקרה משתנה הבקרה במשפט for הוא בדרך כלל מטיפוס שלם. מאחר שבמקרים רבים תפקידו של משתנה הבקרה הוא רק לשלוט במשפט ה- for, ואין בו שימוש בחלקי התוכנית האחרים, שפת #C מאפשרת להצהיר על משתנה הבקרה בתוך הוראת ה-,for כלומר, נוכל לכתוב: for (int i = 1; i <= 10; i++ ) כאשר מצהירים על משתנה הבקרה בתוך משפט ה- for, אין אליו גישה מחוץ לתחום משפט ה- for. שאלה 7.1 בנו טבלת מעקב אחר מהלך ביצוע התוכנית Convertor (לפתרון בעיה 1) עבור הקלט שבו שער ההמרה הוא 4.5 ועשרת המחירים להמרה הם: פרטו בטבלה רק את השורות המתאימות לעיבוד שני הקלטים הראשונים ולעיבוד הקלט האחרון (בדומה לנעשה בפתרון בעיה 1). שאלה 7.2 נסחו עבור כל אחת מן הבעיות האלגוריתמיות הבאות קבוצת תת-משימות לביצוע-חוזר: א. הקלט הוא 20 מרחקים הנתונים במיילים, והפלט הוא 20 המרחקים בקילומטרים (1 מייל = 1.6 קילומטר). ב. הקלט הוא עשר אותיות מן הא"ב האנגלי השונות מהאות Z, והפלט הוא עשר האותיות שעוקבות לאותיות הנתונות. ג. הקלט הוא 40 זוגות של ציונים (זוג ציונים עבור כל תלמיד), והפלט הוא רשימה של ארבעים מספרים: כל מספר הוא הממוצע של זוג הציונים המתאים לו. Console.Write('X'); for (i = 0; i < 10; i++) Console.Write("*"); Console.Write('X'); שאלה 7.3 לפניכם קטע תוכנית: מהו פלט קטע התוכנית? שאלה 7.4 פתחו וישמו אלגוריתם אשר הקלט שלו הוא תו, והפלט שלו הוא שכפול של התו הנקלט חמישים פעמים. למשל, עבור הקלט A יהיה הפלט AAA...AA (חמישים פעמים). בשלב החלוקה לתת-משימות הקפידו על ניסוח תת-משימה לביצוע-חוזר. שאלה 7.5 פתחו וישמו אלגוריתם אשר הקלט שלו הוא 20 מספרים שלמים חיוביים דו-ספרתיים, שלו הוא סכום הספרות לכל אחד מהמספרים הנתונים. והפלט

7 למשל, אם הקלט הוא: הפלט המתאים הוא: בשלב החלוקה לתת-משימות הקפידו על ניסוח תת-משימה לביצוע-חוזר, ובשלב הבדיקה הקפידו על בדיקה מסודרת באמצעות טבלת מעקב. בפתרון בעיה 1 מספר הפעמים לביצוע-חוזר נקבע עוד לפני תחילת ביצוע התוכנית. במקרים רבים, ייתכן כי מספר הפעמים לביצוע-חוזר ידוע לפני שמתחיל ביצועה של ההוראה לביצוע-חוזר, אך לא לפני תחילת ביצוע התוכנית. כלומר הוא תלוי בקלט. מקרה כזה מודגם בבעיה הבאה: בעיה 2 מטרת הבעיה ופתרונה: הצגת ביצוע-חוזר שאורכו נקבע על פי נתון קלט. פתחו אלגוריתם שיקבל כקלט מספר שלם N, ויציג על המסך שורה של כוכביות באורך N. פירוק הבעיה לתת-משימות קליטת אורך לרשימת כוכביות הדפסת כוכביות לפי המספר הנקלט.1.2 רשימת המשתנים עד עתה השתמשנו במספרים קבועים בתנאי לסיום הביצוע-החוזר. בבעיה זו אנו נדרשים לקבל כקלט את מספר הפעמים שתתבצע הלולאה, ולכן התנאי להמשך הביצוע יהיה תלוי בערכו של משתנה. numoftimes מספר הפעמים שיש להציג כוכבית i משתנה הבקרה של הלולאה האלגוריתם numoftimes-á íìù øôñî èåì :íéîòô numoftimes òöá '*' âöä יישום האלגוריתם בפתרון בעיה 1, כאשר רצינו לבצע קבוצת משימות 10 פעמים יישמנו זאת באמצעות משפט for שכותרתו: for(i = 1; i <= 10; i++) (או באמצעות משפט שכותרתו i++),for(i = 1; i <= HOW_MANY; ו- HOW_MANY הוגדר כקבוע שערכו 10). כעת אנחנו רוצים לבצע את הוראה לביצוע-חוזר במשפט for שכותרתו: numoftimes 2.1 פעמים. לכן ניישם את ההוראה for(i = 1; i <= numoftimes; i++)

8 התוכנית המלאה /* הקלט: מספר שלם הפלט: שורה של כוכביות באורך הנתון כקלט */ using System; public class Stars public static void Main () int numoftimes; Console.Write("Enter a number please: "); numoftimes = int.parse(console.readline()); for (int i = 1; i <= numoftimes; i++) Console.Write('*'); } // Main } // Stars סוף פתרון בעיה 2 בתוכנית Stars ראינו שימוש בנתון קלט לקביעת מספר הפעמים לביצוע לולאה. בפיתוח אלגוריתמים בהמשך נשתמש בכך פעמים רבות. באמצעות הבעיה הבאה נכיר שני סוגים של משתנים המשמשים בפתרון בעיות רבות ותבנית העבודה איתם היא שימושית מאוד. כפי שנראה, תבנית העבודה עם משתנים כאלה משתמשת בהוראות לביצוע-חוזר. 3 בעיה מטרת הבעיה ופתרונה: הצגת מונה וצובר ואופן העבודה איתם. פתחו וישמו אלגוריתם אשר הקלט שלו הוא מספר חיובי שלם, ולאחריו רשימה של מספרים ממשיים, שאורכה שווה לערך הקלט הראשון. הפלט שלו הוא ממוצע המספרים ברשימה ומספר המספרים ברשימה שערכם עולה על 50. למשל, עבור הקלט: הפלט המתאים הוא: משום שממוצע המספרים הוא 66.7, ו- 8 מתוכם הם גדולים מ- 50. פירוק הבעיה לתת-משימות ? קליטת אורך הרשימה קליטת רשימת הערכים, סיכומם, ומניית מספר הערכים הגבוהים מ- 50 חישוב ממוצע הערכים הצגה כפלט של הממוצע שחושב ושל מספר הערכים הגבוהים מ- 50 כדי לחשב את הממוצע יש לסכם את הערכים הנתונים בקלט, ובנוסף יש למנות כמה מהערכים הנתונים בקלט הם גבוהים מ- 50. ניתן לבצע הן את פעולת הסיכום והן את פעולת המנייה תוך כדי קריאת נתוני הקלט. כיצד ניתן לבטא זאת כהוראה לביצוע-חוזר?

9 ניתן לבצע את פעולת הסיכום בהוספת כל ערך שנקלט לסכום מצטבר, עוד לפני קריאת הערך הבא. בדומה, ניתן לבצע את פעולת המנייה בהשוואת כל ערך שנקלט ל- 50, ובהגדלת מונה מתאים בכל פעם שהערך שנקלט עולה על 50. לכן, את תת-משימה 2 נוכל לבצע באמצעות ביצוע- חוזר של קבוצת ההוראות הבאה: קליטת ערך הוספת הערך שנקלט לסכום המצטבר השוואת הערך שנקלט ל- 50. אם גבוה מ- 50, הגדלת ערכו של מונה למניית מספר הערכים הגבוהים מ בחירת משתנים מן התת-משימות לביצוע-חוזר ניתן להסיק שיש להשתמש במשתנה אשר יישמר בו ערך תורן שנקרא מהקלט, במשתנה שיצבור את סכום הערכים, ובמשתנה שימנה את מספר הערכים הגבוהים מ- 50. לכן ניעזר במשתנים הבאים: length מטיפוס שלם, ישמור את אורך רשימת המספרים num מטיפוס ממשי, ישמור ערך תורן הנקרא מהקלט sum מטיפוס ממשי, צובר שישמור את סכום הערכים average מטיפוס ממשי, ישמור את ממוצע הערכים counterlarge מטיפוס שלם, מונה שישמור את מספר הערכים הגבוהים מ- 50 שימו : המשתנים sum,num,average הם מטיפוס ממשי, כיוון שערכי הקלט בבעיה הם ממשיים. לעומתם counterlarge הוא מטיפוס שלם כיוון שהוא משמש למנייה. יישום האלגוריתם? את ההוראה לביצוע-חוזר נוכל לנסח באופן הבא: :íéîòô length òöá num-á éùîî êøò èåì.1 sum-á øåîùä øáèöîä íåëñì num ìù åëøò úà óñåä.2 50-î ìåãâ num ìù åëøò íà.3 counterlarge ìù åëøò úà 1-á ìãâä.3.1 אילו הוראות יש להוסיף לפני ההוראה לביצוע-חוזר? שימו : כדי שהצבירה והמנייה יתבצעו באופן נכון, עלינו לאתחל נכונה את הערכים של sum ושל.counterLarge על פי תפקידם של שני המשתנים באלגוריתם יש לאתחל את ערכיהם ב- 0. /* קלט: רשימת ערכים ממשיים פלט: ממוצע הערכים ומספר הערכים הגבוהים מ- 50 */ using System; public class CalcAvgAndCountLargerThan50 public static void Main () הצהרה על קבוע בתוכנית // const int LIMIT = 50; התוכנית המלאה

10 הצהרה על משתנים בתוכנית // אורך רשימת הקלט// length; int ערך קלט תורן // num; double צובר // 0; = sum double ממוצע // average; double מונה למספר הערכים הגבוהים מ- // 50 0; = counterlarge int Console.Write("Enter length of input list: "); length = int.parse(console.readline()); ההוראה לביצוע-חוזר // for (int i = 1; i <= length; i++) Console.Write("Enter number: "); num = double.parse(console.readline()); sum = sum + num; if (num > LIMIT) שקול ל - counterlarge=counterlarge+1 counterlarge++; // }// for average = sum / length; Console.WriteLine("Average is 0}", average); Console.WriteLine("0} numbers are larger than 1}", counterlarge, LIMIT); }// Main }// CalcAvgAndCountLargerThan50 באלגוריתם לפתרון בעיה 3 משמש המשתנה sum כצובר של הערכים הנתונים. צובר פתרון בעיה סוף הוא משתנה אשר תפקידו לצבור ערכים. למשל ניתן להשתמש בצובר לסכימת ערכים. המשתנה counterlarge משמש כמונה של מספר הערכים הגבוהים מ- 50 מבין הערכים הנתונים. מונה 3 הינו משתנה אשר תפקידו למנות את מספר הפעמים שהתרחש אירוע מסוים (למשל מספר הפעמים שנקרא נתון קלט). כיוון שהשימוש במונה הוא לספירה, מונה הוא משתנה שלם. מטיפוס בתוכנית לפתרון בעיה 3 מופיעים המשפטים המבטאים את פעולות הצבירה והמנייה בגוף הלולאה לאחר משפט הקלט. המשפט המבטא את פעולת הצבירה בגוף הלולאה הוא: המשפט המבטא את פעולת המנייה בגוף הלולאה הוא: sum = sum + num; counterlarge++; מאחר שתחזוקה של מונה או של צובר כוללת ביצוע של פעולות עדכון חוזרות ונשנות, נבצע בדרך- כלל פעולות צבירה ומנייה בגוף הלולאה. שימו בשני המקרים גדל המשתנה המשמש כצובר או כמונה בערך כלשהו. במקרה של צובר הוא גדל בערך ששייך לקבוצת הערכים המצטברים. במקרה של מונה הוא גדל ב- 1. באלגוריתם שמשתמשים בו בצובר או במונה יש לאתחל את הצובר או את המונה. בתוכנית לפתרון הבעיה מאותחלים הצובר sum והמונה counterlarge ב

11 מונה של או צובר של א ת חוּל הוא השמת ערך המתאים לתחילת תהליך הצבירה או המנייה. מונה מאותחל בדרך כלל ב- 0. הערך ההתחלתי המתאים לצובר תלוי במהות הצבירה המתבצעת בו. למשל, צובר השומר סכום מצטבר יאותחל ב- 0. שאלה 7.6 שנו את המשפטים הנמצאים בגוף הלולאה שבתוכנית לפתרון בעיה 3, כך שיחושב ממוצע הערכים הגבוהים מ- 50. שאלה 7.7 לפעמים ניתן להשתמש בערכו של מונה לחישוב מספר הנתונים המאופיינים בצורה הפוכה לנתונים שמנינו. למשל, נניח שבבעיה 3 יש להציג גם את מספר הערכים הקטנים או שווים ל- 50. דרך אחת לחישוב מספר זה היא באמצעות שימוש במונה נוסף countersmall (נוסף ל- counterlarge ), אשר ערכו יוגדל ב- 1 בכל פעם שנקלוט ערך הקטן או שווה ל- 50. אך בעצם אין צורך במונה נוסף. ניתן לבצע את החישוב בתום ביצוע הלולאה, באמצעות המונה counterlarge המופיע כבר בתוכנית. כיצד? הוסיפו לתוכנית את ההוראה או את ההוראות המתאימות. שאלה 7.8 ציינו עבור כל אחת מן הבעיות האלגוריתמיות הבאות אם נחוץ לפתרונה צובר, מונה או אף אחד מהשניים: א. קלט: רשימת מחירים, פלט: סך כל המחירים. ב. קלט: רשימת מחירים, פלט: מספר המחירים הגבוהים מ ג. קלט: רשימת מחירים, פלט: מספר המחירים שמרכיב האגורות בהם שונה מ- 0. ד. קלט: רשימת מספרים, פלט: הערך המוחלט של כל אחד מהמספרים. ה. קלט: רשימת מספרים, פלט: הממוצע של הערכים המוחלטים של המספרים. שאלה 7.9 יש לקלוט סדרה של תווים, אשר אורכה שמור במשתנה,listSize ולמנות את מספר התווים שהם אותיות גדולות letters) (capital בא"ב האנגלי. בחרו משתנים, כתבו הוראה לביצוע-חוזר אשר לפניה אתחול מתאים, וישמו אותה במשפט.for שאלה 7.10 מטרת קטע התוכנית הבא היא מניית מספר תווי קלט השונים מן האות A. המשתנים counter ו- listsize הם מטיפוס שלם והמשתנה letter הוא מטיפוס תווי. int counter = ; for (int i = 1; i <= listsize; i++) Console.Write("Enter a char: "); letter = char.parse(console.readline()); if ( ) }// for Console.WriteLine("There are 0} letters different than A", counter); קטע התוכנית כולל לולאה. א. כמה פעמים תתבצע הלולאה עבור הערך 10 ב- listsize?

12 ב. ג. כמה פעמים תתבצע הלולאה עבור הערך 1 ב- listsize? השלימו את קטע התוכנית. שאלה 7.11 נתונה התוכנית הבאה: /* קלט: טור של 16 תווים מטופס ספורטוטו פלט : */ using System; public class Toto public static void Main () const int NUM_OF_GAMES = 16; int d = 0; char score; for (int i = 0; i < NUM_OF_GAMES; i++) Console.Write("Enter the score: "); score = char.parse(console.readline()); if (score == X ) d++; } // for Console.WriteLine(d); } // Main } // Toto קלט התוכנית הוא טור בטופס הספורטוטו. כלומר, 16 תווים שכל אחד מהם מציין תוצאת משחק,1) 2 או.(X א. מהו הפלט עבור הקלט:?1 2 X 1 2 X 1 2 X 1 2 X 1 2 X 2 ב. האם התוכנית כוללת מונה או צובר? אם כן, מהו או מהם? ג. כמה פעמים תתבצע לולאת התוכנית? ד. הביאו דוגמת קלט אשר הפלט עבורה הוא 0. ה. הביאו דוגמת קלט אשר הפלט עבורה הוא 15. ו. מה מאפיין את הקלטים אשר הפלט עבורם הוא 1? ז. מהם ערכי הפלט האפשריים? ח. מהי מטרת התוכנית? בחרו שם משמעותי למשתנה d. שאלה 7.12 פתחו וישמו אלגוריתם אשר הקלט שלו הוא מספר המציין אורך של רשימה ואחריו רשימת מספרים ממשיים באורך הנתון. הפלט שלו הוא סכום החלקים השלמים של המספרים הממשיים הנתונים. מספרים בתחום שאלה 7.13 כתבו קטע תוכנית אשר מקבל כקלט מספר שלם.num התוכנית תגריל num ותבדוק כמה מספרים מבין המספרים שהוגרלו הם זוגיים

13 התוכנית תחשב ותדפיס את סכום שאלה 7.14 כתבו קטע תוכנית שיגריל 10 מספרים תלת-ספרתיים. המספרים האי-זוגיים בלבד מבין המספרים שהוגרלו. בדוגמאות שראינו עד כה השתמשנו בצובר לצבירת סכום. ניתן להשתמש בצובר גם לצבירת מכפלה. כאשר צובר משמש לצבירת מכפלה הוא מאותחל בערך שונה מ- 0. שימו לב לכך בשאלה הבאה: מספרים ויציג כפלט את של מכפלתם 50 שאלה 7.15 פתחו וישמו אלגוריתם שיקבל כקלט רשימה של המספרים הקטנים מ- 10. להעמקה בתבניות מנייה וצבירה פנו לסעיף התבניות המופיע בסוף הפרק. בעיה 3 השתמשה גם בתבנית ממוצע. להעמקה בתבנית ממוצע עבור סדרה שיכולה להכיל יותר מ- 3 ערכים פנו לסעיף התבניות המופיע בסוף הפרק. בעיה 4 מטרת הבעיה ופתרונה: עוד על הוראה לביצוע-חוזר מספר פעמים ידוע מראש: הצגת הוראה לביצוע-חוזר המטפלת בתחום של מספרים, והדגמת שימוש במשתנה הבקרה בתוך גוף הלולאה. פתחו וישמו אלגוריתם שיקבל כקלט מספר שלם, ויציג כפלט את כל המספרים השלמים החיוביים הקטנים מהמספר הנתון. למשל עבור הקלט 5 הפלט המתאים הוא: פירוק הבעיה לתת-משימות ברצוננו לקלוט מספר שלם num ולהציג num-1 ערכים, מ- 1 עד.num-1 אם כך, החלוקה לתת- משימות היא ברורה למדי: 1. קליטת מספר מהקלט 2. הצגה כפלט של כל הערכים החיוביים והשלמים שקטנים מהמספר שנקלט ברור כי לשם ביצוע תת-משימה 2 נזדקק להוראה לביצוע-חוזר, שתתבצע num-1 פעמים. בחירת משתנים ברור כי נזדקק למשתנה עבור הערך הנקרא מהקלט. סביר כי נהיה גם זקוקים למשתנה כלשהו, עבור האיבר התורן להצגה. משתנה זה יאותחל ב- 1 ויקודם בסיום כל סיבוב בלולאה ב- 1, עד אשר ערכו יגיע ל- num. אבל איננו זקוקים למשתנה נוסף כי תיאור זה מתאים בדיוק למשתנה הבקרה של הלולאה! לכן נקבל את רשימת המשתנים הבאה: num מטיפוס שלם, לשמירת הערך הנקרא מהקלט i משתנה הבקרה

14 האלגוריתם כאמור תת-משימה 2 תתבצע באמצעות הוראה לביצוע-חוזר. למעשה בהוראה זו אנו מעוניינים לעבור על תחום של ערכים (מהערך 1 ועד הערך (num-1 ולהציג כל ערך בתחום. כדי לבטא זאת, ננסח את ההוראה לביצוע-חוזר בצורה שונה מעט מזו שראינו באלגוריתמים קודמים בפרק. num-á íìù øôñî èåì.1 :òöá num-1 ãò 1-î íìù i ìë øåáò.2 i ìù åëøò úà âöä.2.1 יישום האלגוריתם את הוראה 2 באלגוריתם שכתבנו ניישם במשפט.for זהו משפט for הדומה מאוד לאלה שראינו בתוכניות קודמות בפרק, רק שמשתנה הבקרה בו אינו משמש רק כדי לשלוט בביצוע הלולאה. יש התייחסות למשתנה הבקרה גם בתוך גוף הלולאה, ולא רק בשלושת הרכיבים שבכותרת הלולאה. /* קלט: מספר שלם כל המספרים השלמים והחיוביים הקטנים מהמספר הנתון */ using System; public class PrintNumbers public static void Main() ערך הנקרא מהקלט // num; int Console.Write("Enter a number: "); num = int.parse(console.readline()); for (int i = 1; i < num; i++) Console.WriteLine(i); } // Main } // PrintNumbers התוכנית המלאה פלט: 4 פתרון בעיה סוף שאלה 7.16 על פי הגדרת בעיה 4, יכול להינתן כנתון ראשון בקלט כל מספר שלם. תארו את מהלך ביצוע התוכנית PrintNumbers אם הערך הראשון בקלט הוא המספר השלם 0. תארו את מהלך הביצוע של התוכנית אם הערך הראשון בקלט הוא המספר השלם 2-. שאלה 7.17 פתחו אלגוריתם שמקבל כקלט מספר חיובי שלם n, מחשב את!n, ומציג את הערך שחושב כפלט. ישמו את האלגוריתם בשפת #C. להזכירכם:!n היא מכפלת המספרים מ- 1 עד n, כלומר:!n. = 2 1 n n שאלה 7.18 פתחו אלגוריתם שמקבל כקלט מספר חיובי שלם n, ומחשב את הסכום:

15 ישמו את האלגוריתם בשפת #C. כזכור הרכיב השלישי במשפט for הוא משפט השמה המתאר את השינוי של משתנה הבקרה בתום כל סיבוב בלולאה. עד עתה כתבנו תוכניות שבהן משתנה הבקרה גדל ב- 1 בתום כל סיבוב של הלולאה. אבל לעתים נרצה לקדם את משתנה הבקרה ב- 2, 3 או אפילו פי 2. שפת #C מאפשרת לנו לתאר שינויים כאלה, פשוט בכתיבת משפט השמה מתאים. הנה מספר דוגמאות לכותרות משפטי for כאלה: for(int i = small; i < big; i = i + 2) for(int i = small; i < big; i = i * 2) for(int i = big; i > small; i--) (כפי שוודאי הבנתם, --i היא דרך מקוצרת לכתוב: - 1 i ). i = במקרים רבים, אכן מתאים לבצע עדכונים שונים של משתנה הבקרה, כפי שמדגימות השאלות הבאות. שאלה 7.19 לפניכם קטע תוכנית הכתוב ב-# C for (int i = 1; i <= 50; i = i * 2) Console.WriteLine(i); א. עקבו בעזרת טבלת מעקב אחר קטע התוכנית? מה יודפס? ב. נניח כי במקום הערך 50 מופיע ערך חיובי שלם כלשהו N. תארו מה מבצע קטע התוכנית כתלות בערך N. שאלה 7.20 פתחו אלגוריתם אשר מקבל כקלט מספר שלם ומציג כפלט את כל המספרים הזוגיים החיוביים הקטנים מהמספר שנקרא. 7.2 מציאת מקסימום או מינימום שתיים מהבעיות הבסיסיות ביותר ב הן חישוב הערך הגדול ביותר או הקטן ביותר ברשימה של ערכים נתונים. פתרונן מהווה תבנית שימושית מאוד. בסעיף זה נערוך היכרות עם בעיות אלו ונראה כי כאשר אורך הרשימה ידוע ניתן לפתור אותן בעזרת הוראה לביצוע-חוזר מספר פעמים ידוע מראש. בעיה 5 מטרת הבעיה ופתרונה: שאורכה נתון אף הוא. הצגת אופן החישוב של הערך הגדול ביותר ברשימת ערכים נתונים מנהל סניף הבנק החליט לבדוק מהו סכום הכסף הגדול ביותר השמור בחשבונות של לקוחות הסניף. פתחו אלגוריתם אשר קולט את מספר החשבונות בסניף, ולאחר מכן את סכום הכסף הנמצא בכל חשבון וחשבון (כמספר שלם). פלט האלגוריתם יהיה הסכום הגבוה ביותר. ישמו את האלגוריתם בשפת #C

16 ניתוח הבעיה בעזרת דוגמאות הרעיון המרכזי בפתרון הבעיה הוא לזכור בכל זמן מהלך הביצוע, מהו הערך הגדול ביותר מבין אלה שכבר נקלטו. ערך זה יושווה תמיד לערך הבא שנקרא מהקלט, ויתעדכן בהתאם לתוצאת ההשוואה. פירוק הבעיה לתת-משימות את הרעיון שתיארנו נוכל לבטא באמצעות התת-משימה הבאה ועל ביצועה יש לחזור לאחר כל קליטת ערך נוסף: השוואת הסכום האחרון שנקלט לסכום הגדול ביותר שנקלט עד כה, ועדכון הסכום הגדול ביותר שנקרא עד כה על פי תוצאת ההשוואה בחירת משתנים נזדקק למשתנה שיזכור את מספר ערכי הקלט (מספר החשבונות), ולמשתנה לשמירת הערך התורן בקלט. בנוסף נזדקק למשתנה כדי לזכור את הערך הגדול ביותר מבין אלה שנקלטו. נבחר את המשתנים הבאים מטיפוס שלם: howmany מספר הערכים ברשימת הנתונים, מספר החשבונות בסניף balance הערך התורן ברשימת ערכי הקלט max לשמירת הסכום הגדול ביותר מבין אלה שנקלטו האלגוריתם max יאותחל בסכום הראשון ברשימה, כיוון שמיד אחרי שנקרא הסכום הראשון, הוא בוודאי הגדול ביותר מבין כל הסכומים שנקראו. כעת יש לקרוא את כל הסכומים האחרים בעזרת לולאת.for לאחר כל קליטה של סכום נוסף, יש להשוות את הסכום החדש שנקלט לסכום הגדול ביותר שנקרא עד כה (השמור ב- max ). אם הסכום החדש גדול מזה השמור ב- max, יישמר ב- max הסכום החדש.? כמה פעמים צריך להתבצע גוף הלולאה? הסכום הראשון נקרא מהקלט עוד לפני הלולאה לצורך האתחול של המשתנה.max לכן הלולאה צריכה להתבצע רק howmany-1 פעמים כדי לקלוט ולעבד את ערכי הקלט הנותרים. יישום האלגוריתם /* ורשימת הסכומים בחשבונות אלה מספר חשבונות בנק, קלט: הסכום הגבוה ביותר ברשימה פלט: */ using System; public class FindMax public static void Main () howmany; int מספר הערכים ברשימה // balance; int // הסכום התורן max; int אלה שנקלטו // הסכום הגבוה ביותר מבין 1. Console.Write("Enter the amount of accounts: "); 2. howmany = int.parse(console.readline());

17 3. Console.Write("Enter the first balance: "); 4. balance = int.parse(console.readline()); 5. balance; max = אתחול המקסימום לסכום הראשון // 6. for(int i = 2; i <= howmany; i++) 6.1. Console.Write("Insert balance of account 0}: ", i); 6.2. balance = int.parse(console.readline()); 6.3. הסכום הנוכחי גדול מהמקסימום הנוכחי // max) if (balance > max = balance; } // for 7. Console.WriteLine("The maximum is 0}", max); }// Main }// FindMax שימו בתוך הלולאה אפשר להשתמש במשתנה הבקרה i כמשתנה לכל דבר. 5 סוף פתרון בעיה שאלה 7.21 בנו טבלת מעקב אחר מהלך ביצוע התוכנית FindMax לפתרון בעיה 5 עבור הקלט: כמה פעמים במהלך ביצוע התוכנית מושם ערך במשתנה?max -9 שאלה 7.22 בפתרון בעיה 5 אותחל max לערכו של הנתון הראשון ברשימה. האם הפתרון היה נכון לו max היה מאותחל בערך קבוע כלשהו, למשל 0? הערה: זכרו כי ייתכן שזהו בנק לא מוצלח במיוחד וכל חשבונות הבנק בו במשיכת יתר, כלומר בעלי ערך שלילי. שאלה 7.23 נתון קטע התוכנית החלקי הבא לחישוב המספר הקטן ביותר ברשימת מספרים חיוביים נתונה, אשר אורכה שמור במשתנה.len min = Console.Write("Enter the list size: "); len = int.parse(console.readline()); for (int i = 1; i <= len; i++) } Console.WriteLine("The minimum is: 0}", min); השלימו את קטע התוכנית (הוסיפו משתנה או משתנים במידת הצורך). במשפט הראשון אתחלו את min לערך קבוע כלשהו (ולא לערך הראשון ברשימה). שאלה 7.24 פתחו וישמו אלגוריתם שמקבל כקלט רשימה של ציונים ב של 40 תלמידים. הפלט הוא הציון הגבוה ביותר מבין התלמידים שנכשלו במבחן (ציון נכשל הוא ציון הנמוך מ- 55 ). שימו לב: כאן הציון התורן הנקרא מהקלט אינו מושווה בכל מקרה למקסימום הנוכחי, אלא רק כאשר הוא קטן מ

18 כפי שראינו בתרגילים הקודמים, יש דרכים שונות לאתחול בתבנית מציאת מקסימום (וכמובן, כך גם לגבי תבנית מציאת מינימום). המשתנה ששומר את המקסימום התורן, צריך בכל שלב לשמור את האיבר הגדול ביותר מבין האיברים שהושוו עד כה. בדרך כלל נעדיף לאתחל את המשתנה הזה בערך האיבר הראשון ברשימה. אכן אחרי שנקלט איבר אחד בלבד, ודאי שהוא הגדול מבין כל אלה שנקלטו. אך ישנם מקרים שעובדה זו אינה מספיקה ולא נוכל להשתמש באתחול כזה. כך למשל בשאלה 7.24: בשאלה זו אנו מעוניינים למצוא מקסימום רק מבין הציונים הנכשלים ולא מבין כל הציונים שבקלט. כלומר לא כל איבר שנקלט צריך להיות מושווה לצורך מציאת מקסימום. בפרט לא בטוח שהאיבר הראשון הוא ציון נכשל ולכן בכלל לא יהיה מועמד למקסימום. לכן יהיה שגוי לקבוע אותו כמקסימום התחלתי. במקרים כאלה נוכל להשתמש בקצוות של טווח הערכים האפשריים. למשל אם מדובר בציונים, ערכם יכול לנוע מ- 0 עד 100. במקרה כזה, יהיה נכון לאתחל את המקסימום התורן ב- 0 (ואת המינימום התורן ב- 100 ). כיוון שברור שהערך הראשון שנשווה למקסימום התורן ערכו הוא 0 לפחות, הרי מיד אחרי ההשוואה הראשונה המקסימום התורן יכיל את האיבר הראשון שהושווה. שימו : לא תמיד ידועים ערכי קצה לטווח הערכים האפשריים! (ראו את שאלה 7.22) להעמקה בתבניות מציאת מקסימום ומציאת מינימום פנו לסעיף התבניות המופיע בסוף הפרק ערך נלווה 7.3 מציאת למקסימום או למינימום בסעיף זה נכיר בעיות הדומות לבעיית מציאת מקסימום או מינימום, אך מעט יותר מורכבות. גם פתרונותיהן מהווים תבניות שימושיות. 6 בעיה מטרת הבעיה ופתרונה: הצגת אופן חישוב מיקומו של הערך הגדול ביותר והקטן ביותר ברשימת ערכים נתונים. בנגן MP3 שמורים 100 שירים. לכל שיר מספר ייחודי משלו בין 1 ל על צג המכשיר מוצג מספרו של השיר הארוך ביותר ושל השיר הקצר ביותר שנמצאים בו. עליכם לפתח אלגוריתם שיאפשר את הצגת המידע הזה. כלומר האלגוריתם יקבל כקלט את רשימת אורכי 100 השירים במכשיר, ופלט האלגוריתם יהיה מספרו של השיר הארוך ביותר ומספרו של השיר הקצר ביותר. כמובן שלצורך פתרון הבעיה יש למצוא את השיר הארוך ביותר ואת השיר הקצר ביותר. כלומר יש למצוא ברשימת אורכי השירים ערך מקסימלי וערך מינימלי. אבל בבעיה זו עלינו לשמור מלבד הערך המקסימלי ומלבד הערך המינימלי גם את מיקומם של ערכים אלה ברשימה. פירוק הבעיה לתת-משימות את הרעיון המרכזי בפתרון נוכל לבטא באמצעות התת-משימה הבאה אשר על ביצועה יש לחזור לאחר כל קליטת ערך נוסף: השוואת אורך השיר האחרון שנקלט לאורך השיר הגדול ביותר שנקלט עד כה ולאורך השיר הקצר ביותר שנקלט עד כה, ובהתאם לתוצאת ההשוואה עדכון ערך המקסימום ומיקום המקסימום ועדכון ערך המינימום ומיקום המינימום

19 בחירת משתנים currentsonglength מטיפוס ממשי, ישמור את אורך השיר הנוכחי. longest מטיפוס ממשי, ישמור את אורך השיר הארוך ביותר שנקלט עד כה. shortest מטיפוס ממשי, ישמור את אורך השיר הקצר ביותר שנקלט עד כה. placelongest מטיפוס שלם, ישמור את מיקומו של השיר הארוך ביותר שנקלט עד כה. placeshortest מטיפוס שלם, ישמור את מיקומו של השיר הקצר ביותר שנקלט עד כה. שימו לבחירת טיפוסי המשתנים: המשתנים longest ו- shortest אשר שומרים את האורך המקסימלי ואת האורך המינימלי חייבים להיות מאותו טיפוס כמו הערכים ברשימת הקלט. כיוון שכאן מדובר באורכי שירים (שיכולים להיות לא שלמים), בחרנו בטיפוס ממשי. לעומתם המשתנים placelongest ו- placeshortest שומרים מיקום ברשימה, ולכן הם מטיפוס שלם. תוכנית המלאה? ה כיצד נדע מהו מיקומו של שיר נתון? לשם כך נוכל להשתמש במשתנה הבקרה של משפט ה- for. כדי שהלולאה תתבצע 99 פעמים משתנה הבקרה יתקדם מ- 2 עד 100, וכך ערכו של משתנה הבקרה יהיה בדיוק מספרו של השיר התורן. שימו : בדיוק כפי שנאתחל את longest ואת,shortest נאתחל גם את placelongest ואת placeshortest באופן עקבי. Longest יאותחל באורכו של השיר הראשון ולכן בהתאם placelongest יאותחל במיקום הראשון (כלומר ב- 1 ). כך גם לגבי האתחול של shortest ושל.placeShortest /* MP3 100 השירים במכשיר רשימת אורכי קלט: ומספרו של השיר הקצר ביותר */ using System; public class Mp3 מספרו של השיר הארוך היותר, פלט: public static void Main () // 100; = NUM_OF_SONGS const int הגדרת קבוע מספר השירים בנגן currentsonglength; double אורך השיר הנוכחי// shortest; double // אורך השיר הקצר ביותר longest; double אורך השיר הארוך ביותר // // placeshortest; int placelongest, מיקומם של השיר הקצר והארוך Console.Write("Enter the length of the first song: "); currentsonglength = double.parse(console.readline()); // המינימום ומקומם אתחולם של המקסימום, longest = currentsonglength; shortest = currentsonglength; placelongest = 1; placeshortest = 1; // נקלט כבר הלולאה מתחילה מ- 2 כיוון שהשיר הראשון for(int i = 2; i <= NUM_OF_SONGS; i++)

20 Console.Write("Enter the length of song 0}: ", i); currentsonglength = double.parse(console.readline()); if (currentsonglength > longest) longest = currentsonglength; placelongest = i; } // if if (currentsonglength < shortest) shortest = currentsonglength; placeshortest = i; } // if } // for Console.WriteLine("The number of the longest song is 0}", placelongest); Console.WriteLine("The number of the shortest song is 0}", placeshortest); } // Main }// Mp3 6 פתרון בעיה סוף שאלה 7.25 פתחו אלגוריתם שיקבל כקלט מספר חיובי שלם המציין את מספר שחקני מכבי ת"א, ואחר כך יקלוט רשימה של נתוני קליעות של השחקנים: עבור כל שחקן ייקלט מספרו (המספר שעל החולצה שלו), ומספר הנקודות שקלע במהלך העונה. פלט האלגוריתם יהיה מספרו של השחקן שקלע הכי הרבה נקודות במהלך העונה. שימו : במקרה זה, אנחנו לא מתבקשים להציג את מיקומו של השחקן שקלע הכי הרבה נקודות אלא את מספרו, לכן משתנה הבקרה המצביע על ה"מיקום" של השחקן התורן בקלט אינו מתאים כי הוא אינו מספרו הסידורי של השחקן. את מספרו של השחקן יש לקרוא מהקלט. להעמקה בתבניות מציאת ערך נלווה למקסימום התבניות המופיע בסוף הפרק. ומציאת ערך נלווה למינימום לסעיף פנו 7.4 ביצוע-חוזר-בתנאי לצורך פתרון הבעיות שראינו עד כה אפשר היה להשתמש בהוראה לביצוע-חוזר אשר מספר הסיבובים בה נקבע לפני תחילת ביצוע הלולאה. בסעיף זה נכיר בעיות אשר בפתרונן אי אפשר לקבוע לפני תחילת הלולאה את מספר הפעמים לביצוע-חוזר. בפתרון בעיות אלה מהלך הלולאה נקבע בהתאם לתנאי. הלולאה מתבצעת שוב ושוב כל עוד התנאי מתקיים. הלולאה מסתיימת כאשר התנאי לא מתקיים. ביצוע-חוזר בשימוש בזקיף בסעיף זה נראה בעיות דומות לאלו שראינו בסעיפים הקודמים. הדמיון מתבטא בכך שגם בבעיות אלו מתבצע עיבוד של רשימת נתוני קלט. ההבדל נעוץ באורך הרשימה המעובדת. בבעיות שהוצגו עד כה אורך הרשימה היה קבוע של התוכנית או נקרא מהקלט. בבעיות שיוצגו בסעיף זה אורך

21 הרשימה אינו ידוע כלל. במקום זאת האיבר האחרון בקלט הוא איבר מיוחד המסמן את סופה של רשימת ערכי הקלט. 7 בעיה מטרת הבעיה ופתרונה: הצגת הוראה לביצוע-חוזר-בתנאי בשימוש בזקיף. צבי עובד בשעות אחר הצהריים בחלוקת משלוחי פרחים. הוא מעוניין להיעזר במחשב הנייד שהוא נושא עמו כדי לחשב בסיום יום העבודה את סכום הטיפים שהרוויח במהלך היום. בכל פעם שצבי מקבל טיפ הוא מקיש את הסכום שקיבל (בשקלים שלמים). בסיום יום העבודה הוא מקיש 1-. פתחו אלגוריתם המקבל כקלט את רשימת הטיפים שקיבל צבי, המסתיימת בערך 1-, ומחשב את סכום הטיפים הכולל. ישמו את האלגוריתם בשפת #C. ניתוח הבעיה בעזרת דוגמאות שאלה 7.26 תארו את הפלט עבור כל אחד מן הקלטים הבאים (משמאל לימין): א ב פירוק הבעיה לתת-משימות.1.2 בניתוח ראשוני של הבעיה ניתן לראות שיש להשתמש בביצוע-חוזר של שתי התת-משימות: קליטת מספר הוספת המספר לסכום (בשימוש בצובר) לו הקלט היה כולל בתחילתו את מספר הערכים בסדרה הנתונה, היינו מפתחים אלגוריתם דומה לאלגוריתמים שבסעיפים הקודמים, בשימוש בהוראה במבנה.íéîòô øôñî òöá אבל מספר הערכים בסדרה לא נתון בתחילת הקלט (כלומר אין אנו יודעים מראש כמה שליחויות עשה צבי באותו היום). במקום זה מופיע בסוף הקלט הערך 1- המציין "סוף קלט". כיצד נשתמש בסימון זה בהוראה לביצוע-חוזר? נשתמש בערך 1- כדי להחליט על סיום ביצוע-חוזר של התת-משימות שתיארנו. כלומר לאחר קליטה של טיפ תורן, יושווה ערך הטיפ לערך 1-. אם הוא שונה מ- 1 - הרי הוא נתון קלט רגיל ולכן יש להוסיפו לסכום המצטבר. אחרת יש לסיים את הביצוע-החוזר. בחירת משתנים האלגוריתם tip מטיפוס שלם, ישמור את הטיפ למשלוח הנוכחי. sum מטיפוס שלם, ישמור את סכום הטיפים. ננסח את הרעיון שתיארנו: :òöá -1 åððéà èì ðù ïåøçàä êøòä ãåò ìë øáèöîä íåëñì èì ðù ïåøçàä êøòä úà óñåä øáèöîä íåëñä ìù åëøò úà âöä

22 ? בהוראה לביצוע-חוזר מסוג זה נבדק תנאי לפני כל סיבוב בלולאה. במקרה זה התנאי הוא êøòä 1-. åððéà èì ðù ïåøçàä אם התנאי מתקיים מתבצע סיבוב נוסף בלולאה. כאשר התנאי לא מתקיים, כלומר הערך שנקלט הוא אכן 1-, מסתיים הביצוע-החוזר. בין ההוראות האלו לא נמצאת עדיין הוראה לקליטת הטיפ התורן. היכן נמקם את הוראת הקלט? יש לבצע את קליטת הטיפ התורן לפני השוואתו לסימן 1-. לכן את הערך הראשון יש לקרוא מהקלט עוד לפני הלולאה. קליטת הערכים הבאים (עד לקליטת סימן סוף הקלט) תהיה ההוראה האחרונה בגוף הלולאה. כלומר מיד כאשר מסתיים עיבוד איבר קלט תורן, ולפני שנבדק קיום התנאי ביחס לאיבר הקלט החדש, מתבצעת קליטה של איבר הקלט החדש. הנה האלגוריתם המלא: 0-á sum äðúùîä úà ìçúà.1 tip-á íìù øôñî èåì.2 :òöá tip -1 ãåò ìë.3 tip êøòä úà sum-ì óñåä.3.1 tip-á íìù øôñî èåì.3.2 sum ìù åëøò úà âöä.4 יישום האלגוריתם את ההוראה במבנה...ãåò ìë,òöá כולל תנאי ניישם ב-# C במשפט.while משפט while בוליאני שקיומו קובע את המשך ביצוע הלולאה. סדרת מספרים שלמים חיוביים המסתיימת ב-( 1 -)*/ קלט: סכומם של המספרים שנקלטו /* פלט: using System; public class SumOfTips public static void Main () tip; int // הטיפ מהמשלוח הנוכחי sum; int // סכום הטיפים המצטבר 1. sum = 0; 2. Console.Write("Enter your first tip for today." + " End the list of tips with -1: "); 3. tip = int.parse(console.readline()); 4. while (tip!= -1) 4.1. sum = sum + tip; 4.2. Console.Write("Enter the next tip." + " End the list of tips with -1: "); 4.3. tip = int.parse(console.readline()); } // while 5. Console.WriteLine("You have earned 0} shekels", sum); }// Main }// SumOfTips מעקב נעקוב אחר מהלך ביצוע התוכנית SumOfTips עבור הקלט 12:

23 while בטבלת מעקב הכוללת משפט המשפט. tip sum tip!=-1 פלט? 0? 0 Enter your first tip true Enter the next tip true Enter the next tip true Enter the next tip false You have earned 21 Shekels אנו כוללים עמודה עבור התנאי הבוליאני שבכותרת המשפט לביצוע sum = 0; Console.Write("Enter your first tip "); tip = int.parse(console.readline()); while (tip!= -1) sum = sum + tip; Console.Write("Enter the next tip. "); tip = int.parse(console.readline()); while (tip!= -1) sum = sum + tip; Console.Write("Enter the next tip. "); tip = int.parse(console.readline()); while (tip!= -1) sum = sum + tip; Console.Write("Enter the next tip. "); tip = int.parse(console.readline()); while (tip!= -1) Console.WriteLine("You have earned 0} shekels", sum); סוף פתרון בעיה 7 נציג את המבנה החדש שהכרנו בפתרון לבעיה 7: הוראה לביצוע-חוזר-בתנאי מבטאת ביצוע-חוזר של תת-משימה התלוי בקיום תנאי. הוראה כזאת נכתבת במבנה...òöá...ãåò ìë גם הוראה כזאת נקראת לולאה, והתנאי להמשך הביצוע-החוזר נקרא תנאי הכניסה ללולאה. הוראה לביצוע-חוזר-בתנאי מיושמת ב-# C במשפט.while המבנה הכללי של משפט while הוא: (ביטוי בוליאני ( while גוף הלולאה: משפט או משפטים לביצוע } ביצוע משפט while מתחיל בחישוב ערכו של הביטוי הבוליאני. אם ערכו true מתבצע גוף הלולאה. בתום ביצוע גוף הלולאה מחושב הביטוי הבוליאני שוב. אם ערכו true מתבצע גוף הלולאה שוב. תהליך זה נמשך כל עוד ערכו של הביטוי הבוליאני הוא.true כאשר ערכו הוא false מסתיים ביצוע משפט ה- while. גוף הלולאה תחום בסוגריים מסולסלים. במקרה שגוף הלולאה מכיל משפט בודד אפשר להשמיט את הסוגריים

24 בטבלת מעקב אחר מהלך ביצוע תוכנית הכוללת משפט while אנו כוללים עמודה עבור תנאי הכניסה ללולאה. ניתן לתאר משפט while באמצעות תרשים הזרימה הבא: התנאי מתקיים ביטוי בוליאני הוראות לביצוע התנאי לא מתקיים כאמור השוני בין בעיה 7 לבעיות הקודמות לה בפרק הוא בהגדרת הקלט. בבעיות הקודמות ניתן מראש אורך רשימת איברי הקלט, ואילו בבעיה 7 סיום רשימת הקלט מסומן בסימן מיוחד (1-). סימן כזה נקרא זקיף. זקיף הוא נתון קלט חריג שתפקידו לסמן את סוף סדרת ערכי הקלט. הזקיף אינו חלק מסדרת הנתונים, ואין לעבד אותו כמו שאר איברי הסדרה. למשל בפתרון בעיה 7 לא הוספנו את הערך 1- לסכום איברי הסדרה כיוון שהזקיף אינו נחשב כחלק מהסדרה! השוני בהגדרת הקלט משפיע גם על מבנה הלולאה. הבדל ברור אחד הוא שבפתרון בעיה 7 השתמשנו בהוראה לביצוע-חוזר-בתנאי שיושמה במשפט,while בעוד שבפתרון הבעיות הקודמות השתמשנו בהוראות לביצוע-חוזר מספר פעמים ידוע מראש שיושמו במשפטי.for אך יש הבדל נוסף האופן שמשולבות הוראות הקלט בתוך הלולאה: בלולאות שבהן השתמשנו בפתרון בעיות קודמות, גוף הלולאה כלל הוראת קלט ומיד לאחריה הוראה לעיבוד הקלט. מבנה זה של גוף הלולאה התאים לבעיות שהיה צריך לעבד בהן כל אחד ואחד מאיברי הקלט באופן אחיד. בבעיות דוגמת בעיה 7 עיבוד איברי הקלט אינו אחיד: העיבוד של הזקיף שונה מהעיבוד של איברים אחרים בקלט. דרוש מבנה המאפשר לקרוא איבר קלט ולעבד אותו רק אחרי שבוצעה בדיקה כי הוא אינו הזקיף. לכן בפתרון בעיות שהגדרת הקלט בהן כוללת זקיף, מתבצעת הוראת קלט ראשונה לפני הלולאה. גוף הלולאה כולל קודם כל הוראה לעיבוד הקלט, ורק אחר כך הוראת קלט. המבנה הכללי של הוראה לביצוע-חוזר לעיבוד רשימת קלט המסתיימת בזקיף: ïåúð èåì : òöá óé æä åððéà èì ðä ïåúðä ãåò ìë èì ðä ïåúðä úà ãáò ïåúð èåì באופן זה, הנתון החדש ייבדק תמיד מיד לאחר קליטתו

25 שאלה 7.27 נתון קטע התוכנית הבא. הקלט הוא רשימת תווים המהווים מילה באנגלית ובסופה הזקיף '*'. int i = 0; char letter; Console.Write("Enter the first letter of the word: "); letter = char.parse(console.readline()); while (letter!= * ) i = i + 1; Console.Write("Enter the next letter of the word: "); letter = char.parse(console.readline()); } Console.WriteLine(i); מהי מטרת קטע התוכנית? שאלה 7.28 פתחו אלגוריתם אשר הקלט שלו הוא רשימת ציונים (נתונים כמספרים שלמים) בין 0 ל- 100 אשר בסופה הזקיף 101, והפלט שלו הוא מספר הציונים ברשימה הגדולים או שווים ל- 60. ישמו את האלגוריתם בשפת #C. שאלה 7.29 אלון ובני מתחרים על תפקיד יושב ראש ועדת קישוט של הכיתה, מועמד זוכה אם יותר מחצי מן הבוחרים הצביעו עבורו. פתחו וישמו אלגוריתם אשר הקלט שלו הוא סדרה של התווים A ו- B (A עבור אלון, B עבור בני), המבטאת את קולות הבוחרים, ומסתיימת בזקיף '#'. הפלט שלו הוא הודעה אם אלון זכה או לא זכה ברוב קולות (כלומר ביותר מחצי מקולות הבוחרים). למשל, עבור הקלט ABBAABBAA# הפלט המתאים הוא:,Alon wins ועבור הקלט.Alon didn t win הפלט המתאים הוא: ABBABBAA# להעמקה בתבנית איסוף בקיזוז פנו לסעיף התבניות המופיע בסוף הפרק. שאלה 7.30 בבחירות לוועד חיות היער מועמדות שלוש חיות: העכבר שמספרו 1, האריה שמספרו 2, והנמלה שמספרה 3. פתחו אלגוריתם אשר הקלט שלו הוא רשימת קולות הבוחרים (כל קול הוא אחד מן המספרים 2 1, או 3) ובסופה הזקיף 0. הפלט הוא הודעה המתארת עד כמה צריכות חיות היער להיזהר: אם האריה קיבל פחות מ- 30% מהקולות עליהן להיזהר מאוד, אם האריה קיבל בין 31% ל- 70% מהקולות עליהן להיזהר קצת, ואם האריה קיבל יותר מ- 71% מהקולות הן יכולות להיות רגועות ואינן צריכות להיזהר כלל. ישמו את האלגוריתם בשפת #C. ומסתיימת מילה באנגלית, סדרת תווים המהווה שאלה 7.31 פתחו אלגוריתם אשר הקלט שלו הוא בזקיף '*'. הפלט שלו הוא מילת הקלט והיא מוצפנת באופן הבא: כל אות במילה מוחלפת באות העוקבת לה "בצורה מעגלית" ב-א"ב האנגלי (כלומר, כל אות מלבד האות Z מוחלפת באות העוקבת לה, והאות Z מוחלפת באות A). למשל עבור הקלט ZEBRA* הפלט הוא.AFCSB ישמו את האלגוריתם בשפת #C

26 שאלה 7.32 טורניר השש-בש מתחיל, אך איבדתם את הקוביות! פתחו אלגוריתם אשר מדמה הטלת שתי קוביות ומציג את תוצאות ההטלה. האלגוריתם מדמה את ההטלות עד שתוצאת ההטלה היא "שש-בש", כלומר צמד המספרים 5 ו- 6 או 6 ו- 5. לסיום האלגוריתם מציג כפלט את מספר ההטלות שהתבצעו עד שהתקבלה התוצאה שש-בש. ישמו את האלגוריתם בשפת #C. ביצוע-חוזר עם תנאי כניסה כלשהו בעיה 8 מטרת הבעיה בזקיף. ופתרונה: הצגת שימוש בהוראה לביצוע-חוזר-בתנאי כניסה כלשהו שאינו תלוי? בתוכנית "הנוסע המתמיד" של חברת התעופה "שחקים" ניתן לצבור מרחקי טיסות. נוסע אשר צובר למעלה מ קילומטרים זוכה בכרטיס טיסה חינם להונולולו. פתחו וישמו אלגוריתם אשר הקלט שלו הוא רשימת מרחקי הטיסות של נוסע אשר זכה בכרטיס חינם (כלומר ידוע שכבר צבר יותר מ ק"מ). הפלט שלו הוא: מספר המרחקים המופיעים ברצף מתחילת הרשימה אשר סכומם המצטבר עולה על 3000, ומספר הקילומטרים שנשארו לנוסע מעבר ל כּ י ת ר ה לצבירות הבאות. למשל עבור הקלט: הפלט המתאים הוא 5, 150 משום שסכומם של כל חמשת המרחק ים עולה על 3000, ואחרי שמופחת מסכום המרחקים הערך 3000 נשארת יתרה של 150. ניתוח הבעיה בעזרת דוגמאות שאלה 7.33 מהו הפלט המתאים עבור כל אחד מן הקלטים הבאים: א ב ברור שבפתרון הבעיה יש לצבור את המרחקים הנתונים. כלומר יש לבצע לולאה שבה ייקלט מרחק נתון ויתווסף לצובר. אך כמה פעמים יש לבצע זאת? בניגוד לבעיות בסעיפים הקודמים שאורך רשימת איברי הקלט בהם היה נתון, או שניתן לנו סימן מיוחד לסיום הקלט (זקיף), בבעיה זו יש לקלוט מרחקים ולהוסיפם לצובר כל עוד ערכו של הצובר איננו גדול מ ברגע שערכו של הצובר גדול מ אין צורך להמשיך בפעולות הקליטה והצבירה. מכאן נובע שיש לבצע את פעולות הקליטה והצבירה רק כל עוד מתקיים התנאי הבא: 3000-ì äååù åà ïè øáöðä çøîä פירוק הבעיה לתת-משימות כל עוד המרחק הנצבר קטן או שווה ל יש לחזור על ביצוע התת-משימות הבאות: קליטת מרחק נתון הוספת המרחק הנתון לצובר הגדלה ב- 1 של "מונה המרחקים"

27 המונה המוזכר בתת-משימה האחרונה ימנה את מספר המרחקים שנצברו בצובר. כאשר יסתיים ביצוע הלולאה, ישמור מונה זה את מספר המרחקים שנצברו עד שהסכום המצטבר עלה על בחירת משתנים dist מטיפוס שלם, ישמור מרחק תורן בקלט sum מטיפוס שלם, צובר שישמור את סכום המרחקים המצטבר counter מטיפוס שלם, מונה שישמור את מספר המרחקים שנצברו האלגוריתם 0-á sum úà ìçúà.1 0-á counter úà ìçúà.2.3 dist-á çøîä úà èåì.3.1 sum-ì dist úà óñåä.3.2 counter úà 1-á ìãâä.3.3 counter ìù åëøò úà âöä.4 sum-3000 ùøôää úà âöä :òöá 3000-ì äååù åà ïè sum ãåò ìë שאלה 7.34 א. ישמו את האלגוריתם בשפת #C. ב. בנו טבלת מעקב אחר ביצוע התוכנית (לפתרון בעיה 8) עבור הקלט: כמה פעמים יתבצע גוף הלולאה? שימו : בכל ביצוע-חוזר של הלולאה נקלט מרחק טיסה אחד, ולכן הערך השמור במשתנה counter הוא בעצם מספר הפעמים שמתבצעת הלולאה. 8 פתרון בעיה סוף שאלה 7.35 נסחו תנאי כניסה בוליאני מתאים עבור כל אחד מן התיאורים הבאים של ביצוע-חוזר: א. סכימת משקלי מכוניות (לצורך מעבר במעבורת) כל עוד הסכום אינו עולה על 100 טון. ב. סכימת המספרים החיוביים השלמים המתחילים ב- 1 עד אשר הסכום גדול מהערך הנתון כקלט. ג. קריאת אותיות עד אשר נקלטות 10 אותיות A. שימו : בסעיף א מתואר הביצוע-החוזר במתכונת של כל עוד ובסעיפים ב ו-ג מתואר הביצוע-החוזר במתכונת של עד אשר. שאלה 7.36 בכל אחד מן הסעיפים הבאים מופיע קטע תוכנית הכולל משפט while ובו תנאי הכניסה חסר. השלימו את תנאי הכניסה לפי מטרת קטע התוכנית, ובנו טבלת מעקב אחר ביצוע הקטע השלם. א. מטרת הקטע: הצגה של המספר הזוגי הקטן ביותר אשר גדול מנתון הקלט בהינתן שהקלט הוא מספר חיובי. Console.Write("Enter a number: "); num = int.parse(console.readline()); i = 0;

28 ב. while ( ) i = i + 2; Console.WriteLine(i); בנו טבלת מעקב אחר ביצוע קטע התוכנית השלם עבור הקלט 9. מטרת הקטע: הצגה של מכפלת שני נתוני הקלט, בהינתן שהם מספרים שלמים חיוביים. Console.Write("Enter a number: "); x = int.parse(console.readline()); Console.Write("Enter a number: "); y = int.parse(console.readline()); counter = 0; sum = 0; while ( ) sum = sum + x; counter = counter + 1; } Console.WriteLine(sum); בנו טבלת מעקב אחר ביצוע קטע התוכנית השלם עבור הקלט 4. 3 שאלה 7.37 נתון קטע התוכנית הבא אשר הקלט שלו הוא מספר חיובי שלם: Console.Write("Enter a number: "); limit = int.parse(console.readline()); s = 0; c = 0; while (s < limit) c = c + 1; s = s + c; } Console.WriteLine(c); קטע התוכנית כולל מונה c וצובר s. הצובר צובר את ערכיו של המונה במהלך הביצוע-החוזר. א. מהו הפלט עבור הקלט 1? מהו הפלט עבור הקלט 11? ב. ציינו שני קלטים שונים שעבורם יהיה הפלט 5. מהו מספר הפעמים לביצוע-החוזר עבור קלטים אלה? ג. מהי מטרת קטע התוכנית? היעזרו בטבלת מעקב כדי לענות על סעיפים א ו-ב. שאלה 7.38 נתון קטע התוכנית הבא אשר הקלט שלו הוא מספר חיובי שלם, ו- TOP_LIMIT הוא קבוע שערכו 100: Console.Write("Enter a number: "); num = int.parse(console.readline()); mult = 1; i = 0; while ((i < num) && (mult < TOP_LIMIT)) i = i + 1; mult = mult * i;

29 } Console.WriteLine(mult); קטע התוכנית הנתון כולל צובר mult אשר צובר ערך של מכפלה, והוא מאותחל בערך 1. א. מהו הפלט עבור הקלט? 2 ומהו הפלט עבור הקלט 5? ב. מהו הקלט שעבורו יהיה הפלט 24? ומהו מספר הפעמים של הביצוע-החוזר עבור קלט זה? ג. מהי מטרת קטע התוכנית? היעזרו בטבלת מעקב כדי לענות על סעיפים א ו-ב. שאלה 7.39 פתחו אלגוריתם אשר הקלט שלו הוא מספר חיובי שלם, והפלט שלו הוא החזקה הקטנה ביותר 3 של 2 אשר גדולה מנתון הקלט. למשל: עבור הקלט 7 הפלט הדרוש הוא 8 (כי 8= 2), ועבור הקלט 4 8 הפלט הדרוש הוא 16 (כי 16= 2). ישמו את האלגוריתם בשפת #C. במהלך הפיתוח הקפידו על ניסוח תת-משימות לביצוע-חוזר ועל ניסוח תנאי לביצוע-חוזר. שימו : באלגוריתם זה יש להשתמש בצובר של מכפלה, ולא בפעולת החזקה Pow המוגדרת במחלקה.Math בלולאות while שראינו עד כה תנאי הכניסה היו דומים למדי זה לזה. הם כללו תמיד השוואה של משתנה, אשר ערכו גדל במהלך הביצוע-חוזר של הלולאה, לחסם אשר נשמר במשתנה או נקבע מפורשות. הביצוע-החוזר הסתיים כאשר ערכו של המשתנה גדל ועבר את החסם (או השתווה לו). אבל תנאי כניסה כאלה הם רק סוג אחד של תנאי כניסה ללולאה. בפתרון הבעיה הבאה נראה דוגמה לתנאי כניסה מסוג אחר. 9 בעיה מטרת הבעיה ופתרונה: הצגת תבנית פירוק מספר שלם חיובי כלשהו לספרותיו. פתחו וישמו אלגוריתם אשר הקלט שלו הוא מספר שלם חיובי והפלט שלו הוא מספר ספרות המספר. למשל: עבור ה קלט 31 הפלט הדרוש הוא 2 ועבור הקלט הפלט הדרוש הוא 5. בפרקים קודמים כבר עסקנו בפירוק של מספר שלם לספרותיו, אך שם מספר ספרותיו היה קטן וידוע. בבעיה הנתונה מספר הספרות איננו ידוע ויכול להיות גדול מאוד. פירוק הבעיה לתת-משימות מה יהיו התת-משימות לביצוע-חוזר עבור מניית ספרות המספר? ומה יהיה התנאי לחזרה על ביצוע תת-משימות אלה? נוכל "לקצץ" את ספרות המספר אחת אחת ולמנות את מספר הספרות הנקצצות. נעשה זאת באמצעות תת-משימות לביצוע-חוזר הכוללות קיצוץ ספרה מן המספר והגדלת מונה ב- 1. קיצוץ ספרה יתבצע באמצעות חלוקה בשלמים של המספר ב- 10 ח. לוקה זו תביא לקיצוץ ספרת האחדות (הספרה הימנית ביותר). למשל במקום המספר 534 יתקבל המספר 53. אם כך, ננסח את התת-משימות הבאות לביצוע-חוזר: קיצוץ ספרת האחדות הגדלה ב- 1 של מונה הספרות

30 יש לבצע תת-משימות אלו כל עוד "יש מה לקצץ", כלומר כל עוד המספר הנותר במהלך הביצוע- החוזר גדול מ- 0. לכן התנאי לביצוע-חוזר יהיה: î-0. ìåãâ øúåðä øôñîä בחירת משתנים נבחר שני משתנים מטיפוס שלם: num ישמור את המספר הניתן כקלט, וספרותיו נקצצות digits מונה שישמור את מספר הספרות שנקצצו יישום האלגוריתם /* קלט: מספר חיובי שלם פלט: מספר הספרות במספר הנתון */ using System; public class DigitCount public static void Main () מספר הספרות // 0; = digits int int num; המספר המעובד // Console.Write("Enter a number: "); num = int.parse(console.readline()); while (num > 0) num = num / 10; digits++; } Console.WriteLine("The number of digits is 0}", digits); }// Main }//DigitCount 9 פתרון בעיה סוף להעמקה בתבניות הפרק. פירוק מספר לספרותיו ובניית מספר פנו לסעיף התבניות המופיע בסוף שאלה 7.40 א. שנו את התוכנית DigitCount לפתרון בעיה 9, כך שהפלט יכלול את סכום ספרות המספר, למשל עבור הקלט 153 הפלט המתאים הוא 9. ב. שנו את התוכנית DigitCount לפתרון בעיה 9, כך שהפלט יכלול רק את מספר הספרות האי-זוגיות במספר הנתון. למשל עבור הקלט 150 הפלט המתאים הוא 2. ג. שנו את התוכנית DigitCount לפתרון בעיה 9, כך שהפלט יכלול רק את מכפלת ספרות המספר. שימו לב לאתחול נכון של המשתנה השומר את המכפלה. שאלה 7.41 נתון קטע התוכנית החלקי הבא, אשר הקלט שלו הוא שני מספרים שלמים חיוביים x ו- y ומטרתו היא הצגת שארית החלוקה בשלמים של x ב- y (כלומר תוצאת החישוב.(x%y בקטע התוכנית מתבצע החישוב הדרוש באמצעות פעולת חיסור

31 Console.Write("Enter a number: "); x = int.parse(console.readline()); Console.Write("Enter a number: "); y = int.parse(console.readline()); while ( ) x = x y; Console.WriteLine( ); השלימו את קטע התוכנית. שאלה 7.42 שנו את הקטע הנתון בשאלה הקודמת כך שיציג גם את מנת החלוקה של x ב- y, (כלומר את תוצאת החישוב.(x/y יש לבצע את החישובים הדרושים באמצעות פעולות חיבור וחיסור בלבד! שאלה 7.43 שני תלמידים המשחקים זה נגד זה מותחים בתחילת המשחק קו באורך N סנטימטרים (1 > N). השחקנים מחליפים תורות לסירוגין. כל שחקן מקצר בתורו את הקו לחצי מאורכו. השחקן אשר מקצר בתורו את הקו לאורך של פחות מסנטימטר אחד מנצח במשחק. למשל אם אורכו של הקו הוא 8 ס"מ, השחקן הראשון יקצר את הקו ל- 4 ס"מ והשחקן השני יקצר את הקו ל- 2 ס "מ, השחקן הראשון יקצר את הקו לס"מ אחד והשחקן השני יקצר את הקו ל- 0.5 ס"מ וינצח במשחק. פתחו וישמו אלגוריתם אשר הקלט שלו הוא אורכו ההתחלתי של הקו, והפלט שלו הוא הודעה מיהו השחקן המנצח (הראשון או השני). שאלה 7.44 במשחק אסימונים שחקן מניח 2 אסימונים בתור הראשון, 4 אסימונים בתור השני, 8 אסימונים בתור השלישי, וכך הלאה בכל תור מוכפל מספר האסימונים. נתון קטע התוכנית הבא אשר הקלט שלו הוא מספר האסימונים ההתחלתי של השחקן, והפלט שלו צריך להיות המספר הסידורי של התור אשר בו לא ניתן להמשיך לשחק לפי השיטה המתוארת. למשל, עבור הקלט המייצג מספר אסימונים התחלתי 9, הפלט הדרוש הוא 3, כיוון שאחרי שהניח 2 אסימונים בתור הראשון ו- 4 אסימונים נוספים בתור השני יוותרו לשחקן רק 3 אסימונים (ולא 8 אסימונים, כפי שנדרש לתור השלישי). קטע התוכנית שגוי. המספר הסידורי של התור הנוכחי // ;0 = turn int מספר אסימונים למשחק בתור הנוכחי // ;0 = tokensincurrentturn int סכום אסימונים כולל בתורות שהתבצעו עד כה // ;0 = totalplayedtokens int מספר אסימונים התחלתי // starttokens; int Console.Write("Enter number of tokens to start with: "); starttokens = int.parse(console.readline()); while (totalplayedtokens <= starttokens) turn = turn + 1; tokensincurrentturn = tokensincurrentturn * 2; totalplayedtokens = totalplayedtokens + tokensincurrentturn; } Console.WriteLine("The game cannot go on after 0} turns", turn); ציינו מהי השגיאה ותקנו אותה